package com.sky.chapter3.lock;

/**
 * @author : wushikai
 * <p>
 * date : 2022-07-04
 * 如何分析互斥?
 * 分析代码是否互斥的方法，先找出synchronized作用的对象是谁，如果多个线程操作的方法中synchronized作用的锁对象一样，
 * 那么这些线程同时异步执行这些方法就是互斥的。如下代码:
 */
public class synchronizedDemo4 {

    //作用于当前类的实例对象
    private synchronized void m1() {
    }

    //作用于当前类的实例对象
    private synchronized void m2() {
    }

    //作用于当前类的实例对象
    public void m3() {
        synchronized (this) {
        }
    }

    //作用于当前类Class对象
    private static synchronized void m4() {
    }

    //作用于当前类Class对象
    private static void m5() {
        synchronized (synchronizedDemo4.class) {
        }
    }

    public static class MT extends Thread {
        synchronizedDemo4 synchronizedDemo4;

        public MT(synchronizedDemo4 synchronizedDemo4) {
            this.synchronizedDemo4 = synchronizedDemo4;
        }

        @Override
        public void run() {
            super.run();
        }
    }


    /**
     * 线程t1、t2、t3中调用的方法都需要获取d1的锁，所以他们是互斥的
     * t1/t2/t3这3个线程和t4不互斥，他们可以同时运行，因为前面三个线程依赖于d1的锁，t4依赖于d2的锁
     * t5、t6都作用于当前类的Class对象锁，所以这两个线程是互斥的，和其他几个线程不互斥
     */
    public static void main(String[] args) {
        synchronizedDemo4 demo4 = new synchronizedDemo4();
        Thread t1 = new Thread(() -> {
            demo4.m1();
        });
        t1.start();
        Thread t2 = new Thread(() -> {
            demo4.m2();
        });
        t2.start();

        Thread t3 = new Thread(() -> {
            demo4.m2();
        });
        t3.start();


        synchronizedDemo4 demo41 = new synchronizedDemo4();
        Thread t4 = new Thread(() -> {
            demo41.m2();
        });
        t4.start();


        Thread t5 = new Thread(() -> {
            synchronizedDemo4.m4();
        });
        t5.start();
        Thread t6 = new Thread(() -> {
            synchronizedDemo4.m5();
        });
        t6.start();
    }
}
